package com.template.common.base;

import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.baomidou.mybatisplus.extension.service.IService;
import com.template.common.util.PageUtil;

import java.util.List;

/**
 * 基础服务接口
 * 
 * @author template
 * @since 2024-01-01
 */
public interface BaseService<T extends BaseEntity> extends IService<T> {

    /**
     * 分页查询
     * 
     * @param pageNum 页码
     * @param pageSize 页大小
     * @return 分页结果
     */
    default PageUtil.PageResult<T> page(Integer pageNum, Integer pageSize) {
        Page<T> page = PageUtil.createPage(pageNum, pageSize);
        IPage<T> result = page(page);
        return PageUtil.convertPageResult(result);
    }

    /**
     * 分页查询（带排序）
     * 
     * @param pageNum 页码
     * @param pageSize 页大小
     * @param orderBy 排序字段
     * @param orderDirection 排序方向
     * @return 分页结果
     */
    default PageUtil.PageResult<T> page(Integer pageNum, Integer pageSize, String orderBy, String orderDirection) {
        Page<T> page = PageUtil.createPage(pageNum, pageSize, orderBy, orderDirection);
        IPage<T> result = page(page);
        return PageUtil.convertPageResult(result);
    }

    /**
     * 分页查询（带条件）
     * 
     * @param pageNum 页码
     * @param pageSize 页大小
     * @param queryWrapper 查询条件
     * @return 分页结果
     */
    default PageUtil.PageResult<T> page(Integer pageNum, Integer pageSize, QueryWrapper<T> queryWrapper) {
        Page<T> page = PageUtil.createPage(pageNum, pageSize);
        IPage<T> result = page(page, queryWrapper);
        return PageUtil.convertPageResult(result);
    }

    /**
     * 分页查询（带条件和排序）
     * 
     * @param pageNum 页码
     * @param pageSize 页大小
     * @param queryWrapper 查询条件
     * @param orderBy 排序字段
     * @param orderDirection 排序方向
     * @return 分页结果
     */
    default PageUtil.PageResult<T> page(Integer pageNum, Integer pageSize, QueryWrapper<T> queryWrapper, 
                                       String orderBy, String orderDirection) {
        Page<T> page = PageUtil.createPage(pageNum, pageSize, orderBy, orderDirection);
        IPage<T> result = page(page, queryWrapper);
        return PageUtil.convertPageResult(result);
    }

    /**
     * 根据ID查询
     * 
     * @param id ID
     * @return 实体
     */
    default T getById(Long id) {
        return getById(id);
    }

    /**
     * 根据条件查询单个
     * 
     * @param queryWrapper 查询条件
     * @return 实体
     */
    default T getOne(QueryWrapper<T> queryWrapper) {
        return getOne(queryWrapper);
    }

    /**
     * 根据条件查询列表
     * 
     * @param queryWrapper 查询条件
     * @return 列表
     */
    default List<T> list(QueryWrapper<T> queryWrapper) {
        return list(queryWrapper);
    }

    /**
     * 保存实体
     * 
     * @param entity 实体
     * @return 是否成功
     */
    default boolean save(T entity) {
        return save(entity);
    }

    /**
     * 根据ID更新
     * 
     * @param entity 实体
     * @return 是否成功
     */
    default boolean updateById(T entity) {
        return updateById(entity);
    }

    /**
     * 根据条件更新
     * 
     * @param entity 实体
     * @param queryWrapper 查询条件
     * @return 是否成功
     */
    default boolean update(T entity, QueryWrapper<T> queryWrapper) {
        return update(entity, queryWrapper);
    }

    /**
     * 根据ID删除
     * 
     * @param id ID
     * @return 是否成功
     */
    default boolean removeById(Long id) {
        return removeById(id);
    }

    /**
     * 根据条件删除
     * 
     * @param queryWrapper 查询条件
     * @return 是否成功
     */
    default boolean remove(QueryWrapper<T> queryWrapper) {
        return remove(queryWrapper);
    }

    /**
     * 根据ID批量删除
     * 
     * @param ids ID列表
     * @return 是否成功
     */
    default boolean removeByIds(List<Long> ids) {
        return removeByIds(ids);
    }

    /**
     * 根据ID判断是否存在
     * 
     * @param id ID
     * @return 是否存在
     */
    default boolean existsById(Long id) {
        return getById(id) != null;
    }

    /**
     * 根据条件判断是否存在
     * 
     * @param queryWrapper 查询条件
     * @return 是否存在
     */
    default boolean exists(QueryWrapper<T> queryWrapper) {
        return count(queryWrapper) > 0;
    }

    /**
     * 根据条件统计数量
     * 
     * @param queryWrapper 查询条件
     * @return 数量
     */
    default long count(QueryWrapper<T> queryWrapper) {
        return count(queryWrapper);
    }
}
